home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / minix / up1510b.tgz / up1510b / src / commands / nroff / strings.c < prev    next >
C/C++ Source or Header  |  1990-07-23  |  5KB  |  274 lines
  1. /*
  2.  *    strings.c - String input/output processing for nroff word processor
  3.  *
  4.  *    adapted for atariST/TOS by Bill Rosenkranz 11/89
  5.  *    net:    rosenkra@hall.cray.com
  6.  *    CIS:    71460,17
  7.  *    GENIE:    W.ROSENKRANZ
  8.  *
  9.  *    original author:
  10.  *
  11.  *    Stephen L. Browning
  12.  *    5723 North Parker Avenue
  13.  *    Indianapolis, Indiana 46220
  14.  *
  15.  *    history:
  16.  *
  17.  *    - Originally written in BDS C;
  18.  *    - Adapted for standard C by W. N. Paul
  19.  *    - Heavily hacked up to conform to "real" nroff by Bill Rosenkranz
  20.  */
  21.  
  22. #undef NRO_MAIN                    /* extern globals */
  23.  
  24. #include <stdio.h>
  25. #include "nroff.h"
  26.  
  27.  
  28.  
  29. /*------------------------------*/
  30. /*    defstr            */
  31. /*------------------------------*/
  32. defstr (p)
  33. register char  *p;
  34. {
  35.  
  36. /*
  37.  *    Define a string. top level, read from command line.
  38.  *
  39.  *    we should read string without interpretation EXCEPT:
  40.  *
  41.  *    1) number registers are interpolated
  42.  *    2) strings indicated by \* are interpolated
  43.  *    3) arguments indicated by \$ are interpolated
  44.  *    4) concealed newlines indicated by \(newline) are eliminated
  45.  *    5) comments indicated by \" are eliminated
  46.  *    6) \t and \a are interpreted as ASCII h tab and SOH.
  47.  *    7) \\ is interpreted as backslash and \. is interpreted as a period.
  48.  *
  49.  *    currently, we do only 3. a good place to do it would be here before
  50.  *    putstr, after colstr...
  51.  */
  52.  
  53.     register char  *q;
  54.     register int    i;
  55.     char        name[MNLEN];
  56.     char        defn[MXMLEN];
  57.  
  58.  
  59.  
  60.     name[0] = '\0';
  61.     defn[0] = '\0';
  62.  
  63.  
  64.     /*
  65.      *   skip the .ds and get to the name...
  66.      */
  67.     q = skipwd (p);
  68.     q = skipbl (q);
  69.  
  70.     /*
  71.      *   ok, name now holds the name. make sure it is valid (i.e. first
  72.      *   char is alpha...). getwrd returns the length of the word.
  73.      */
  74.     i = getwrd (q, name);
  75.     if (!name[0])
  76.     {
  77.         fprintf (err_stream,
  78.             "***%s: missing or illegal string definition name\n",
  79.             myname);
  80.         err_exit (-1);
  81.     }
  82.  
  83.     /*
  84.      *   truncate to 2 char max name.
  85.      */
  86.     if (i > 2)
  87.         name[2] = EOS;
  88.  
  89.  
  90.     /*
  91.      *   skip the name to get to the string. it CAN start with a " to
  92.      *   have leading blanks...
  93.      */
  94.     q = skipwd (q);
  95.     q = skipbl (q);
  96.  
  97.  
  98.  
  99.     /*
  100.      *   read rest of line from input stream and collect string into
  101.      *   temp buffer defn
  102.      */
  103.     if ((i = colstr (q, defn)) == ERR)
  104.     {
  105.         fprintf (err_stream,
  106.             "***%s: string definition too long\n", myname);
  107.         err_exit (-1);
  108.     }
  109.  
  110.  
  111.     /*
  112.      *   store the string
  113.      */
  114.     if (putstr (name, defn) == ERR)
  115.     {
  116.         fprintf (err_stream,
  117.             "***%s: string definition table full\n", myname);
  118.         err_exit (-1);
  119.     }
  120. }
  121.  
  122.  
  123.  
  124.  
  125.  
  126. /*------------------------------*/
  127. /*    colstr            */
  128. /*------------------------------*/
  129. colstr (p, d)
  130. register char  *p;
  131. char           *d;
  132. {
  133.  
  134. /*
  135.  *    Collect string definition from input stream
  136.  */
  137.  
  138.     register int    i = 0;
  139.  
  140.     if (*p == '\"')
  141.         p++;
  142.  
  143.     while (*p != EOS)
  144.     {
  145.         if (i >= MXMLEN - 1)
  146.         {
  147.             d[i - 1] = EOS;
  148.             return (ERR);
  149.         }
  150.         d[i++] = *p++;
  151.     }
  152.     d[i] = EOS;
  153.     return (i);
  154. }
  155.  
  156.  
  157.  
  158.  
  159.  
  160. /*------------------------------*/
  161. /*    putstr            */
  162. /*------------------------------*/
  163. putstr (name, p)
  164. register char  *name;
  165. register char  *p;
  166. {
  167.  
  168. /*
  169.  *    Put string definition into (macro) table
  170.  *
  171.  *    NOTE: any expansions of things like number registers SHOULD
  172.  *    have been done already. strings and macros share mb buffer
  173.  */
  174.  
  175.  
  176.     /*
  177.      *   any room left? (did we exceed max number of possible macros)
  178.      */
  179.     if (mac.lastp >= MXMDEF)
  180.         return (ERR);
  181.  
  182.     /*
  183.      *   will new one fit in big buffer?
  184.      */
  185.     if (mac.emb + strlen (name) + strlen (p) + 1 > &mac.mb[MACBUF])
  186.     {
  187.         return (ERR);
  188.     }
  189.  
  190.  
  191.     /*
  192.      *   add it...
  193.      *
  194.      *   bump counter, set ptr to name, copy name, copy def.
  195.      *   finally increment end of macro buffer ptr (emb).
  196.      *
  197.      *   string looks like this in mb:
  198.      *
  199.      *    mac.mb[MACBUF]        size of total buf
  200.      *    lastp < MXMDEF        number of macros/strings possible
  201.      *    *mnames[MXMDEF]        -> names, each max length
  202.      *    ...______________________________...____________________...
  203.      *        / / /|X|X|0|string definition      |0| / / / / / / /
  204.      *    .../_/_/_|_|_|_|_________________...___|_|/_/_/_/_/_/_/_...
  205.      *            ^
  206.      *            |
  207.      *            \----- mac.mnames[mac.lastp] points here
  208.      *
  209.      *   both the 2 char name (XX) and the descripton are null term and
  210.      *   follow one after the other.
  211.      */
  212.     ++mac.lastp;
  213.     mac.mnames[mac.lastp] = mac.emb;
  214.     strcpy (mac.emb, name);
  215.     strcpy (mac.emb + strlen (name) + 1, p);
  216.     mac.emb += strlen (name) + strlen (p) + 2;
  217.     return (OK);
  218. }
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225. /*------------------------------*/
  226. /*    getstr            */
  227. /*------------------------------*/
  228. char   *getstr (name)
  229. register char  *name;
  230. {
  231.  
  232. /*
  233.  *    Get (lookup) string definition from namespace
  234.  */
  235.  
  236.     register int    i;
  237.  
  238.     /*
  239.      *   loop for all macros, starting with last one
  240.      */
  241.     for (i = mac.lastp; i >= 0; --i)
  242.     {
  243.         /*
  244.          *   is this REALLY a macro?
  245.          */
  246.         if (mac.mnames[i])
  247.         {
  248.             /*
  249.              *   if it compares, return a ptr to it
  250.              */
  251.             if (!strcmp (name, mac.mnames[i]))
  252.             {
  253. /*!!!debug            puts (mac.mnames[i]);*/
  254.  
  255.                 if (mac.mnames[i][1] == EOS)
  256.                     return (mac.mnames[i] + 2);
  257.                 else
  258.                     return (mac.mnames[i] + 3);
  259.             }
  260.         }
  261.     }
  262.  
  263.     /*
  264.      *   none found, return null
  265.      */
  266.     return (NULL_CPTR);
  267. }
  268.  
  269.  
  270.  
  271.  
  272.  
  273.  
  274.